home *** CD-ROM | disk | FTP | other *** search
/ Whiteline: Alpha / Whiteline Alpha.iso / tex / tools / dvi / 24nadel.c next >
Encoding:
C/C++ Source or Header  |  1994-09-22  |  5.1 KB  |  223 lines
  1. /*************************************************************************
  2. ****    Kern des universellen 24-Nadeltreibers                                                    ****
  3. ****    Sollte von Headerdatei aufgerufen werden                                                ****
  4. *************************************************************************/
  5.  
  6. #include <portab.h>
  7. #include <stdlib.h>
  8. #include <string.h>
  9.  
  10. #include "mintbind.h"
  11. #include "treiber.h"
  12.  
  13.  
  14. #ifndef STEP_360
  15. #error "Bitte diese Datei nur per #include lesen!"
  16. #endif
  17.  
  18.  
  19. UBYTE     *INIT             = "\033@\033x\1";
  20. UBYTE     *GRAFIK_180 = "\033*\047\0";
  21. UBYTE     *GRAFIK_360 = "\033*\050\0";
  22. UBYTE     *STEP_180     = "\033\063\1";
  23.  
  24.  
  25.  
  26.  
  27. VOID    block_out( UBYTE *dest, UBYTE *src, WORD ende, LONG offset, WORD hoehe )
  28. {
  29.     WORD        i, j, k;
  30. #if 0
  31.     if(  hoehe != 0  && hoehe < 8)
  32.     {
  33.         /* Nur wenn es wirklich nötig ist die langsame Bitpfriemelei */
  34.         for(    i=0;    i<=ende;    i++  )
  35.         {
  36.             /* Byte-Pfriemeln */
  37.             for(    j=7;    j>=0;  j--    )
  38.             {
  39.                 *dest = 0;
  40.                 for(    k=0;    k<hoehe;    k++  )
  41.                     *dest |= ((src[0+k*offset]>>j)&1)<<(7-k);
  42.             }
  43.             dest++;
  44.             src++;
  45.         }
  46.         return;
  47.     }
  48. #endif
  49.     /* So ist wesentlich schneller */
  50.     for(    i=0;    i<=ende;    i++  )
  51.     {
  52.         /* Byte-Pfriemeln */
  53.         for(    j=7;    j>=0;  j--    )
  54.         {
  55.             *dest = 0;
  56.             *dest |= ((src[0]>>j)&1)<<7;
  57.             *dest |= ((src[offset]>>j)&1)<<6;
  58.             *dest |= ((src[offset*2]>>j)&1)<<5;
  59.             *dest |= ((src[offset*3]>>j)&1)<<4;
  60.             *dest |= ((src[offset*4]>>j)&1)<<3;
  61.             *dest |= ((src[offset*5]>>j)&1)<<2;
  62.             *dest |= ((src[offset*6]>>j)&1)<<1;
  63.             *dest |= (src[offset*7]>>j)&1;
  64.             dest++;
  65.             *dest |= ((src[offset*8]>>j)&1)<<7;
  66.             *dest |= ((src[offset*9]>>j)&1)<<6;
  67.             *dest |= ((src[offset*10]>>j)&1)<<5;
  68.             *dest |= ((src[offset*11]>>j)&1)<<4;
  69.             *dest |= ((src[offset*12]>>j)&1)<<3;
  70.             *dest |= ((src[offset*13]>>j)&1)<<2;
  71.             *dest |= ((src[offset*14]>>j)&1)<<1;
  72.             *dest |= (src[offset*15]>>j)&1;
  73.             dest++;
  74.             *dest |= ((src[offset*16]>>j)&1)<<7;
  75.             *dest |= ((src[offset*17]>>j)&1)<<6;
  76.             *dest |= ((src[offset*18]>>j)&1)<<5;
  77.             *dest |= ((src[offset*19]>>j)&1)<<4;
  78.             *dest |= ((src[offset*20]>>j)&1)<<3;
  79.             *dest |= ((src[offset*21]>>j)&1)<<2;
  80.             *dest |= ((src[offset*22]>>j)&1)<<1;
  81.             *dest |= (src[offset*23]>>j)&1;
  82.             dest++;
  83.         }
  84.         src++;
  85.     }
  86. }
  87. /* 20.1.93 */
  88.  
  89.  
  90.  
  91. /* Zur Zeit wird fast nicht optimiert; Zum einen sollte jetzt fast jeder
  92.  * Drucker arbeiten; Zum anderen habe ich keinen 24-Nadeldrucker zum Testen
  93.  * Bastler sind hier zur Arbeit aufgefordert!
  94.  */
  95. static UBYTE    tmp[8192];
  96.  
  97. WORD    drucke( UBYTE *p, LONG weite, LONG max_zeile, LONG h_dpi, LONG v_dpi )
  98. {
  99.     UBYTE v_modus, *v_step, *grafik;
  100.     LONG    max_spalte, zeile, lz, links, linker_rand, rechts;
  101.     LONG    h_len, len, i;
  102.     WORD    th;
  103.  
  104.     th = (WORD)get_tempfile( "n24" );
  105.     if(  th<0  )
  106.         return -1;
  107.  
  108.     grafik = GRAFIK_360;
  109.     v_step = STEP_360;
  110.     if(  h_dpi<200    )
  111.     {
  112.         grafik = GRAFIK_180;
  113.         h_dpi = 180;
  114.     }
  115.     else
  116.         h_dpi = 360;
  117.  
  118.     if(  v_dpi<200    )
  119.     {
  120.         v_step = STEP_180;
  121.         v_dpi = 180;
  122.     }
  123.     else
  124.         v_dpi = 360;
  125.  
  126.         /* Ab hier wird es ernst */
  127.     if(  weite<WEITE*h_dpi/360L  ) /* Für DINA3 vergrößern! */
  128.         max_spalte = (weite+7)/8;
  129.     else
  130.         max_spalte = WEITE*h_dpi/(360*8L);
  131.  
  132.         /* Diverse Variablen initialisieren */
  133.     zeile = 0;
  134.     weite = (weite+15L)/16L;
  135.     weite *= 2;
  136.     p += weite*OBEN + LINKS;    /* Nicht druckbare Ränder*/
  137.     max_zeile -= OBEN;
  138.     if(  HOEHE>0    &&    max_zeile>HOEHE  )
  139.         max_zeile = HOEHE;
  140.     lz = 0;
  141.     v_modus = v_dpi/180;
  142.     linker_rand = 0;
  143.  
  144.     Fwrite( th, strlen(INIT), INIT ); /* Reset + LQ-Mode */
  145.     Fwrite( th, 3L, v_step );
  146.  
  147.     /* Endlich drucken */
  148.     max_zeile--;
  149.     while(    zeile<max_zeile )
  150.     {
  151.         /* Leerzeilen überspringen */
  152.         for(    ;  ist_leerzeile( p, max_spalte )  &&  zeile<(max_zeile-1);  lz++, zeile++    )
  153.             p += weite;
  154.  
  155.         if(  v_dpi==360  )
  156.         {
  157.             if(  lz&1  )
  158.                 Fwrite( th, 3L, v_step );
  159.             lz >>= 1;
  160.         }
  161.         
  162.         while(    lz>0    )
  163.         {
  164.             Fwrite( th, 2L, "\033J" );
  165.             if(  lz>255  )
  166.                 Fwrite( th, 1L, "\xFF" );
  167.             else
  168.                 Fwrite( th, 1L, ((char *)(&lz)+3) );    /* Long = 4 Bytes! */
  169.             Fwrite( th, 1L, "\xA" );
  170.             lz -= 255;
  171.         }
  172.         if(  zeile==max_zeile  )
  173.             break;
  174.  
  175.             /* Ränder feststellen */
  176.         for(    rechts=max_spalte-1;    ist_next_leer( p+rechts, weite, v_modus*24 )    &&    rechts>linker_rand;  rechts--  )
  177.             ;
  178.         rechts++;
  179.         links = 0;
  180.         len = rechts;
  181.         h_len = 5;
  182.         strcpy( tmp, grafik );
  183.         tmp[3] = (UBYTE)(8*(rechts-links) % 256);
  184.         tmp[4] = (UBYTE)(8*(rechts-links) / 256);
  185.         if(  len>0    )
  186.             memset( tmp+h_len, 0, 24*len );
  187.  
  188.         /* Oder auch weniger bei geringerer Auflösung */
  189.         for(    lz=0;  lz<v_modus;    zeile++  )
  190.         {
  191.             i = (max_zeile - 1 - zeile)/v_modus;
  192.             i = 24-i;
  193.             if(  i<0    )
  194.                 i = 0;
  195.             block_out( tmp+h_len, p+links, (WORD)(rechts-links), weite*v_modus, (WORD)i );
  196.             Fwrite( th, h_len+24*(rechts-links), tmp );
  197.             Fwrite( th, 1L, "\xD" );
  198.             p += weite;
  199.  
  200.             if(  ++lz<v_modus  )
  201.             {
  202.                 Fwrite( th, 2L, v_step );
  203.                 Fwrite( th, 2L, "\1\xA" );
  204.             }
  205.         }
  206.         lz = 1+23*v_modus;    /* + eine Zeile mehr überspringen */
  207.         p += (weite*lz);
  208.         zeile += lz;
  209.  }
  210.  
  211.         /* Ende Seite */
  212.     if(  1!=Fwrite( th, 1L, "\xC" )  )
  213.     {
  214.         /* Platz reichte nicht aus */
  215.         Fclose( th );
  216.         return -1;
  217.     }
  218.     return th;
  219. }
  220. /* 17.1.93 */
  221. /* Viele kleine Fehler gefunden und gefixt. 6.5.93 Marcus Haebler */
  222.  
  223.